Computer Understanding of Conventional Metaphoric Language

Metaphor is a conventional and ordinary part of language. An approach to metaphor, based on the explicit representation of knowledge about metaphors, has been developed. This approach asserts that the interpretation of conventional metaphoric language should proceed through the direct application of speci c knowledge about the metaphors in the language. midas (Metaphor Interpretation, Denotation, and Acquisition System) is a computer program that has been developed based upon this approach. midas can be used to represent knowledge about conventional metaphors, interpret metaphoric language by applying this knowledge, and dynamically learn new metaphors as they are encountered during normal processing. 2 1 Conventional Metaphor Consider the problem of understanding the conventional metaphoric language in the following examples. (1) How can I kill a process? (2) How can I get into Lisp? (3) You can enter Emacs by typing \emacs" to the shell. (4) Nili gave Marc her cold. (5) In ation is eating up our savings. The italicized words in each of these examples are being used to metaphorically refer to concepts that are quite distinct from those that might be considered the normal meanings of the words. Consider the use of enter in (3). Enter is being used, in this example, to refer to the actions on a computer system that result in the activation of a program. This use is clearly di erent from what might be called the ordinary or basic meaning of the word that has to do with the actions that result in an object entering an enclosure. While the word enter is used metaphorically in (3), this metaphor is neither novel nor poetic. Instead, the metaphorical use of enter results from a conventional systematic conceptual metaphor that allows computer processes to be viewed as enclosures. The various actions and states that have to do with the activation, deactivation, and use of computer processes are viewed as the standard actions and states that have to do with enclosures. This conceptual metaphor, structuring processes as enclosures, underlies the normal conventional way of speaking about these processes. Therefore, the uses of the words get into in (2) and enter in (3) are the ordinary conventional ways of expressing these concepts that nevertheless involve a systematic, productive metaphor. 2 The Metaphoric Knowledge Approach The main thrust of the Metaphoric Knowledge approach to metaphor is that the interpretation of metaphoric language proceeds through the direct application of speci c knowledge about the metaphors in the language. Moreover, it is asserted that the mechanisms that are used to apply this knowledge should be fundamentally the same as those used to interpret direct non-metaphorical language. Under this view, the proper way to approach the study of metaphor is to study the underlying details of individual metaphors and systems of metaphors in the language. This approach follows on the metaphor work of Lako and Johnson (Lako and Johnson, 1980) and the computational approaches to metaphor described in (Jacobs, 1985; Martin, 1986; Martin, 1987; Martin, 1988; Norvig, 1987). It is useful here to consider an analogy between the study of metaphor and the study of syntax. Broadly speaking, the study of syntax is concerned with the representation, use and acquisition of sets of complex facts that may be said to represent the grammar of a language. The approach to metaphor, described here, proceeds in a similar fashion. In 3 particular, it addresses the representation, use and acquisition of explicit knowledge about the metaphors in the language. This approach has been embodied in midas (Metaphor Interpretation, Denotation, and Acquisition System)(Martin, 1988). midas is a set of computer programs that can be used to perform the following tasks: explicitly represent knowledge about conventional metaphors, apply this knowledge to interpret metaphoric language, and learn new metaphors as they are encountered. Note that the term metaphor has historically been applied to a wide range of disparate phenomena. These have ranged from Kuhnian-shift type rethinkings of entire conceptual domains, to explicit formulaic simile statements like Man is a Wolf. It is important, therefore, to identify the particular kind of phenomena that the midas approach addresses. midas is solely concerned with modeling the everyday natural language task faced by readers of ordinary text. In particular, the quick and correct interpretation of ordinary text containing usually unnoticed commonplace metaphors. In order to make the problem of understanding metaphors more concrete, consider the implications of (1) through (3) for a system like the unix Consultant (Wilensky et al., 1984; Wilensky et al., 1988). uc is a natural language consultant system that provides naive computer users with advice on how to use the unix operating system. Metaphors like those shown above are ubiquitous in technical domains like unix. A system that is going to accept natural language input from users and provide appropriate natural language advice must be prepared to handle such metaphorical language. midas has been integrated into uc in order to give it the ability to handle this kind of metaphoric language. Perhaps more importantly, unix o ered an ideal domain, rich in metaphors, in which midas could be tested. Consider the following uc session illustrating the processing of a series of user queries. # How can I kill a process? Applying metaphor: Killing-Terminate You can kill a process by typing ^ C to the shell. # Tell me how to get out of emacs. Applying metaphor: Exit-Emacs You can get out of emacs by typing ^ X^ C. # Do you know how to enter lisp? Applying metaphor: Enter-Lisp You can enter lisp by typing ``lisp'' to the shell. In each of these examples, uc/midas attempts to nd the most coherent interpretation of the user's question, given its current knowledge of the conventions of the language. This involves checking the structure of the input against the constraints posed by all the possible conventional metaphorical and non-metaphorical interpretations. In each of these examples, 4 the only coherent interpretation is the one found through the application of a known unix metaphor. Consider the details of the Enter-Lisp metaphor in the last example. The knowledge that midas has of this metaphor speci es that the action of invoking certain kinds of processes can be viewed as an entering action, where the process invoked plays the role of the enclosure, and that the user performing the action is viewed as entering the enclosure. midas uses its knowledge of these conventional associations to infer that the use of enter by the user is most appropriately interpreted as a process invocation. 3 Previous Computational Approaches The Metaphoric Knowledge approach, embodied in midas, developed as a reaction to the strategies employed in previous computational approaches to metaphor. These approaches have adopted, what I call, a knowledge-de cient approach. By this, I mean an approach that makes no use of explicit knowledge about the metaphors in the language. These approaches do, of course, make use of other kinds of knowledge. They are de cient only with respect to explicit knowledge of the metaphorical conventions of the language. The knowledge-de cient approach has been manifested in two distinct processing strategies lying at opposite ends of a spectrum involving the representation and use of language conventions. The word-sense strategy (Hirst, 1987; Wilensky and Arens, 1980; Riesbeck, 1975; Small and Rieger, 1982) recognizes that there are conventional uses of words that deviate from ordinary compositional, or literal, meaning. This strategy addresses the problem by listing each separate use as an isolated and unmotivated word-sense in the lexicon. Under this approach the uses of enter lisp and get out of emacs in the previous examples are handled by distinct isolated lexical entries. While this approach adequately allows known conventional senses to be interpreted correctly, it nevertheless has a number of serious shortcomings. The listing of each separate use as an isolated fact in the lexicon simply fails to capture the generalizations among senses of di erent words or among the senses of a single word. Consider that a system that had knowledge about the use of get out of would not be able to handle related uses of exit or leave without listing them as separate facts. This failure to capture generalizations among word-senses provides the system with no basis for the prediction or classi cation of new uses as they are encountered. At the opposite end of the spectrum, lie approaches that are based on analogy or similarity (Carbonell, 1981; DeJong and Waltz, 1983; Fass, 1988; Gentner et al., 1988; Indurkhya, 1987; Wilks, 1978). These approaches assert that metaphors arise from an underlying conceptual similarity or analogy between the concepts representing the literal meaning of the words and the concepts underlying the ultimate meaning of the utterance. These approaches are at the opposite end of the spectrum because they use no knowledge about the conventions of the language. In particular, there is no use of any knowledge about metaphors that are a conventional part of the language. The task of interpreting metaphoric language is seen as a special purpose problem-solving task requiring access to knowledge and inference 5 techniques that are not otherwise a part of the normal language processing faculties. Note that the computational costs of these analogy mechanisms are radically higher than those posed for direct non-metaphorical language. While the details of each approach di er, they are all fundamentally based on the stage model (Searle, 1979) where the literal meaning of the sentence is computed and judged to be ill-formed, and then an analogy system is employed to search for an appropriate target meaning. The metaphoric knowledge approach taken in midas is an attempt to fuse the advantages of each of these approaches. The conventionality of most metaphor is captured through the representation of explicit knowledge about known metaphors. Furthermore, the rich structure underlying the system of metaphors in the language is captured in this representation. This rich structure allows the exibility to apply the known metaphors in novel situations. At the same time the use of direct knowledge in most cases allows midas to avoid the high computational costs of the analogy approaches. 4 Constraints from Psycholinguistic Research While it is di cult to apply results from psycholinguistics to computational models in a direct fashion, these results can nevertheless pose useful rough constraints. There are two basic results that are of interest here from psycholinguistics. Both stem stem from research on the relative di culty of understanding what has been called literal language versus various kinds of metaphorical, idiomatic, and indirect language (Gerrig, 1989; Gibbs, 1984; Gibbs, 1989; Ortony et al., 1978; Glucksberg et al., 1982; Keysar, 1989). The rst result that will be used is that the time needed to process various kinds of nonliteral language does not di er signi cantly from the time taken to interpret direct language in the appropriate context. Speci cally, there is no experimental evidence to indicate that there is a radical di erence between the time taken to interpret metaphorical language and that taken to interpret direct non-metaphorical language. This constraint has been referred to as the total time constraint (Gerrig, 1989). This rough equivalence of time to process was taken as one of the basic constraints in the development of midas. Speci cally, it was decided that the mechanisms used by midas to interpret conventional metaphors could not di er signi cantly, in terms of processing time, from the interpretation mechanisms assumed for direct non-metaphoric language. The empirical result of equivalent time to process does not necessarily imply that similar mechanisms are at work. However, in the absence of more ne-grained empirical results indicating that fundamentally di erent processes are at work, it seems reasonable to assume that the mechanisms will be similar. Therefore, a further constraint was adopted that the mechanisms developed for interpreting metaphoric language should be fundamentally the same as those assumed for direct non-metaphoric language. The second result of interest has to do with the non-optionality of metaphorical interpretations. The studies of Glucksberg (Glucksberg et al., 1982) and Keysar (Keysar, 1989) have shown that metaphorical interpretations may be generated even when there is a wellformed and pragmatically appropriate literal interpretation. More speci cally they show 6 that metaphorical interpretations are produced when they are consistent with the context regardless of the well-formedness of a literal interpretation. This is in con ict with the stage model that predicts metaphorical interpretations should only be produced when the literal is ill{formed on some semantic or pragmatic grounds. This basic result was incorporated into midas by simply requiring the system to return all literal and metaphorical interpretations that are consistent with the given constraints. The well-formedness of a literal interpretation is therefore not allowed to block the generation of metaphorical one. As we will see in Section 7.4 this may result in midas returning multiple interpretations. 5 Overview of MIDAS This section provides a brief overview of the three-part midas approach to metaphor. In particular, it introduces the following three issues. Representation: The explicit representation of the conventional metaphors in a language in the form of explicit associations between concepts. Interpretation: The correct and e cient application of this metaphoric knowledge to the interpretation of metaphoric language. Learning: The dynamic acquisition of new knowledge about metaphors for which no known metaphor provides a coherent explanation. 5.1 Knowledge Representation Consider the following simple example of a conventional unix metaphor. The metaphorical use of the word in re ects a systematic metaphorical structuring of unix processes as enclosures. (6) I am in Emacs. Metaphors like this may be said to consist of the following component concepts: a source component, a target component, and a set of conventional associations from the source to target. The target consists of the concepts to which the words are actually referring. The source refers to the concepts in terms of which the intended target concepts are being viewed. In this example, the target concepts are those representing the state of currently using a computer process. The source concepts are those that involve the state of being contained within some enclosure. The approach taken here is to explicitly represent conventional metaphors as sets of directed structured associations between source and target concepts. The metaphor speci es how the source concepts re ected in the surface language correspond to various target concepts. In this case, the metaphor consists of component associations that specify that the state of being enclosed represents the idea of currently using the editor, where the user plays the role of the enclosed thing, and the Emacs process plays the role of the enclosure. These associations also serve to delimit the particular parts of the various source and target domains that are relevant to particular conventional metaphors. 7 Note that these source-target relations should not be thought of as weak associative links between disparate domains. Such associations would not capture the rich structure inherent in the system of metaphors. In particular, the relations used in midas are directional in that they directly specify which concepts constitute the source and which the target. Moreover, they explicitly delimit what aspects of the source and target domains play a role in any given metaphor. Note also that these source-target associations are represented at the conceptual and not the lexical level. Any single lexical item or expression that can be construed as referring to the source concept of a known metaphor, may invoke that metaphor. In this example, the source component of the metaphor is attached to the concept of being enclosed, not to the lexical item in. These sets of metaphoric associations, along with the concepts that comprise the source and target domains, are represented using the kodiak (Wilensky, 1986) representation language. kodiak is an extended semantic network language in the tradition of kl-one (Brachman and Schmolze, 1985) and its variants. The details of kodiak and the representation of metaphoric knowledge will be described in Section 6.1. These sets of metaphoric associations representing conventional metaphors are fulledged kodiak concepts. As such, they can be related to other concepts and arranged in abstraction hierarchies using the inheritance mechanisms provided by kodiak. The hierarchical organization of conventional metaphoric knowledge is the primary means used to capture the regularities exhibited by the system of metaphors in the language. Speci cally, kodiak is used to represent specialized domain speci c metaphors, pervasive high-level metaphors, and the systems of relations among related metaphors. 5.2 Interpretation The interpretation process in midas is basically one that views a given input sentence as providing a set of constraints on possible interpretations. midas checks the input constraints against all the possible interpretations that can be conventionally associated with the input. Interpretations that are coherent with the constraints are returned. The possible conventional interpretations may include direct non-metaphoric interpretations, as well as all the conventional metaphors that are invoked by the input. Consider the details of the following shortened trace 1 of a unix example which will be discussed more fully in Section 7. In this example, uc calls upon midas to nd a coherent interpretation for this use of enter. midas nds, and attempts to apply, all the conventional metaphorical and non-metaphorical concepts associated directly with, or inherited by, this concept. In this case, it nds that the only conventional interpretation that is consistent with the input is the one that results from the application of the known Enter-Lisp metaphor. 1Output from MIDAS is shown in typewriter font. The following notations are used: concepts whose names end in a number represent instances of that category, uparrows indicate the immediate dominating category, while a rightarrow between two concepts points from a source concept to a target concept. 8 > (do-sentence) Interpreting sentence: How can I enter lisp? Interpreting concreted input. (A Entering50 (" Entering) (enterer50 (" enterer) (A I203 (" I))) (entered50 (" entered) (A Lisp58 (" Lisp)))) A parser rst produces a syntactic analysis and a preliminary semantic representation of the input. At this point in the analysis, uc calls upon midas to begin a deeper analysis of this initial representation. Failed interpretation: Entering50 as Entering. Failed interpretation: Entering50 as Enter-Association. Valid known metaphorical interpretation: Entering50 as Enter-Lisp. The case structure of this preliminary representation is checked against the semantic constraints of all the interpretations conventionally associated with the Entering concept. In this case, midas nds that the direct interpretation and one of the other possible entering metaphors can be rejected before the appropriate Enter-Lisp metaphor is found. It is important to realize that the order of the search performed here is arbitrary. midas is exhaustively nding all conventional interpretations that are consistent with the input. The determination of consistency for any given interpretation is independent of the consistency of any of the other possible interpretations. In particular, the well-formedness of a direct, or literal, interpretation has no e ect on whether or not a metaphorical interpretation will be found. It follows from this that the order of the search through the possible interpretations has no e ect on which interpretations will ultimately be produced. Applying conventional metaphor Enter-Lisp. (A Enter-Lisp (" Container-Metaphor) (enter-lisp-res enter-res ! lisp-invoke-result) (lisp-enterer enterer ! lisp-invoker) (entered-lisp entered ! lisp-invoked) (enter-lisp-map Entering ! Invoke-Lisp)) 9 Mapping input concept Entering50 to concept Invoke-Lisp30 Mapping input role enterer50 with filler I203 to target role lisp-invoker30 Mapping input role entered50 with filler Lisp58 to target role lisp-invoked30 Yielding interpretation: (A Invoke-Lisp30 (" Invoke-Lisp) (lisp-invoked30 (" lisp-invoked) (A Lisp58 (" Lisp))) (lisp-invoker30 (" lisp-invoker) (A I203 (" I)))) midas then begins the process of mapping from the given source concepts to the appropriate target concepts based on the constraints imposed by the metaphor. The mapping process, called metaphoric unviewing, creates a new instance of the metaphor itself along with the attendant source and target concepts. Any further inferences that need to be performed by uc are based on this newly created target concept. In this example, the source concept of Entering is mapped to the target concept Invoke-Lisp as speci ed by the metaphor. Calling UC on input: (A How-Q207 (" How-Q) (topic206 (" topic) (A Invoke-Lisp30 (" Invoke-Lisp) (lisp-invoked30 (" lisp-invoked) (A Lisp58 (" Lisp))) (lisp-invoker30 (" lisp-invoker) (A I203 (" I)))))) UC: You can enter lisp by typing ``lisp'' to the shell. Finally, uc uses this new target concept as the basis for answering the user's question by using its long-term knowledge about how to initiate the Lisp system. Note that uc makes use of the metaphor in expressing its answer to the user. 5.3 Learning midas will inevitably face the situation where a metaphor is encountered for which none of its known metaphors provides an adequate explanation. This situation may result from the existence of a gap in the system's knowledge-base of conventional metaphors, or from an encounter with a novel metaphor. In either case, the system must be prepared to handle the situation. 10 Consider the following example. The user has employed the conventional unixmetaphor that the termination of an ongoing process can be viewed as a killing. However, unlike the previous example, midas nds that it is initially unable to interpret this example because it has no knowledge of this conventional metaphor. More precisely, it determines that the given input can not adequately satisfy the constraints associated with any of the concepts conventionally associated with the word kill. > (do-sentence) Interpreting sentence: How can I kill a process? Interpreting concreted input. (A Killing16 (" Killing) (killer16 (" killer) (A I46 (" I))) (kill-victim16 (" kill-victim) (A Computer-Process10 (" Computer-Process)))) Failed interpretation: Killing16 as Killing. Failed interpretation: Killing16 as Kill-Delete-Line. Failed interpretation: Killing16 as Kill-Sports-Defeat. Failed interpretation: Killing16 as Kill-Conversation. No valid interpretations. At this point, midas has exhausted all the possible conventional interpretations of the primal representation. In particular, the direct non-metaphoric interpretation and three known metaphorical interpretations are rejected because their restrictions of the role of the kill-victim fail to match the semantics of the concept lling that role in the input, a computer-process. This example illustrates the operation of the learning component ofmidas, the Metaphor Extension System (MES). This system is invoked by midas when it discovers a metaphor for which it has no adequate knowledge. The task of the MES is to attempt to extend its knowledge of some existing metaphor in a way that will yield a coherent interpretation for the new use and provide a basis for directly understanding similar uses in future. Analogical reasoning is at the core of midas's learning mechanism. However, unlike previous metaphor systems, midas does not attempt to draw an analogy between source and target domains of a metaphor. Rather, midas attempts to reason analogically from known metaphors. In this case, the system nds and extends a closely related known metaphor that also uses kill to mean a kind of terminate. midas nds that there is a known metaphor covering the use of kill in kill a conversation to mean to terminate. This known metaphor is applied 11 analogically to the current situation through the common notion of process meaning a series of related events happening over time. =========================================================== Entering Metaphor Extension System =========================================================== Attempting to extend existing metaphor. Selecting metaphor Kill-Conversation to extend. Attempting a similarity extension inference. Creating new metaphor: Killing-Terminate-Computer-Process (A Killing-Terminate-Computer-Process (" Kill-Metaphor) (kill-victim-c-proc-termed-map kill-victim ! c-proc-termed) (killer-c-proc-termer-map killer ! c-proc-termer) (killing-terminate-computer-process-map Killing ! Terminate-Computer-Process)) Final interpretation of input: (A How-Q46 (" How-Q) (topic46 (" topic) (A Terminate-Computer-Process10 (" Terminate-Computer-Process) (c-proc-termer10 (" c-proc-termer) (A I46 (" I))) (c-proc-termed10 (" c-proc-termed) (A Computer-Process10 (" Computer-Process)))))) UC: You can kill a computer process by typing ^ C to the shell. Finally, the target concept determined by the mes is used to provide an answer to the user. The approach taken in midas to the understanding of new or unknown metaphors is called the Metaphor Extension Approach. The basic thrust of this approach is that a new metaphor can best be understood by extending an existing well-understood metaphor or combining several known metaphors in a systematic fashion. Under this approach, the ability to understand and learn new metaphors depends critically on systematic knowledge about existing known metaphors. This approach, therefore, shifts the processing emphasis in the case of novel metaphors away from the notion of attempting to determine the right target concept by a direct 12 matching against the literal source. Rather, an attempt is made to determine the correct target through the use of an existing related metaphor. Therefore in this example, no attempt is made to nd the intended target meaning by looking at the source details of literal slaying, rather the system examines the target concept of an already existing terminating as killing metaphor. The focus of the remainder of this article is on the representation and use of metaphoric knowledge to interpret known conventional metaphors. Details of the midas approach to the acquisition of new metaphors can be found in (Martin, 1990). Lako and Turner (Lako and Turner, 1988) address the general issue of the relationship between well-known conventional metaphors and novel poetic metaphor. 6 Knowledge Representation Details This section rst provides a brief description of the kodiak representation language, it then reviews some of the systematic aspects of conventional metaphor that need to be captured, and shows how this is accomplished using kodiak. While the emphasis in this section is on the use of kodiak to represent metaphors, it should be noted that all the required background world knowledge of the source and target domains, as well as knowledge of unix, is represented in kodiak 6.1 KODIAK kodiak is best seen as an extended semantic network language in the tradition of kl-one and its variants. The motivations for its development and its theoretical underpinnings are best described in (Wilensky, 1986). The actual implementation described here is a modi ed version of the one developed by Norvig (Norvig, 1987) for the faustus text inferencing system. The description of kodiak provided here will be brief, introducing only those ideas and notations needed in order to follow the rest of the article. More details will be introduced along the way as necessary. 2 Facts in kodiak are represented as nodes connected together with primitive links. The language provides three types of nodes and eight primitive kinds of links. Figure 1 lists each node and link, gives an icon or label that will be used to denote it in diagrams, and provides a brief description of each type. 6.2 Representing Individual Metaphors The rst requirement for the representation is to be able to capture conventional metaphors as explicit concepts consisting of sets of associations between source and target concepts. Consider again Example (1), repeated here. (1) How can I kill a process? 2kodiak as an actual representation language and as a theory is in an almost constant state of ux. Therefore the details described here di er in detail but not in spirit from those described in (Jacobs, 1985; Wilensky, 1986; Norvig, 1987). 13 Absolutes (Rectangles) concepts, e.g. person, action, idea Relations (Implicit) relations between concepts, e.g actor-of-acting Aspectuals (Circles) arguments of relations, e.g. actor Dominate (D) a concept is a sub-class of another class Instance (I) a concept is an instance of a class View (V) a concept can be viewed as another concept Constrain (C) llers of an aspectual must be of some class Argument (a) associates aspectuals with a relation Fill (F) an aspectual refers to some instance Equate (=) two concepts are co-referential Di er (6=) two concepts may not be co-referential Figure 1: Primitives of kodiak This example, from the unix domain, involves the conventional metaphor that to kill an ongoing process means to terminate it. The target concepts involve computer processes and the actions that terminate them. The source concept is that of the action of causing a living thing to die. The metaphor consists of the source concepts, target concepts, and the set of associations linking them. Conventional metaphors like this one are captured in kodiak through the use of a structured association called a metaphor-sense. A metaphor-sense is a concept that consists of a set of component relations that link a set of source concepts to a set of target concepts. The individual component associations are relations called metaphor-maps. These metaphor-maps are the associations used to connect source and target concepts. Moreover, these relations are given the status of fulledged concepts, since relations in kodiak are concepts. To reiterate, metaphor-senses, along with their component metaphor-maps, are represented explicitly as concepts along with the concepts that make up the various non-metaphorical source and target concepts. Figure 2 shows the kodiak representation of the source domain from (1). It states that a killing is a kind of action with a result that is a death-event which is in turn an event. The kill-victim of the killing is an inherited role from action indicating that the kill-victim is e ected by the action. The kill-victim is constrained by the C link to be a living-thing and the killer must be an animate-agent. Finally the equate links require that the kill-victim must be the same as the dier participant of the death-event. This gure also introduces an additional notational abbreviation. The links labelled S (for Slot) in this diagram are an abbreviation for more complex relations. It is frequently the case that when a relation between two absolutes is being shown, it is in terms of one of 14 Action Event Death−Event Patient Actor Killer Animate Kill Victim Kill Result Living−Thing Killing